"""
WebSocket 控制器 - 用于管理WebSocket连接和消息处理
"""
import json
from typing import Dict, Any, Optional, List

from PyQt5.QtCore import QObject, pyqtSignal

from app.services.service_locator import ServiceLocator
from app.services.websocket_service import IWebSocketService
from app.services.comment_service import ICommentService
from app.utils.logger import Logger


class WebSocketController(QObject):
    """
    WebSocket 控制器 - 用于管理WebSocket连接和消息处理
    """
    
    # 信号定义
    message_received = pyqtSignal(dict)  # 收到消息信号
    connection_status_changed = pyqtSignal(str)  # 连接状态变化信号
    error_occurred = pyqtSignal(str)  # 错误信号
    
    def __init__(self, parent=None):
        """
        初始化 WebSocket 控制器
        
        @param parent: 父对象
        """
        super().__init__(parent)
        
        # 获取日志记录器
        self.logger = Logger.get_logger("websocket_controller")
        
        # 获取服务
        self._websocket_service: Optional[IWebSocketService] = ServiceLocator.get(IWebSocketService)
        self._comment_service: Optional[ICommentService] = ServiceLocator.get(ICommentService)
        
        # 检查WebSocket服务是否可用，如果不可用，尝试等待一下再获取
        retry_count = 0
        max_retries = 3
        while not self._websocket_service and retry_count < max_retries:
            self.logger.warning(f"WebSocket服务不可用，尝试重新获取 (尝试 {retry_count + 1}/{max_retries})")
            import time
            time.sleep(0.1)  # 等待100毫秒
            self._websocket_service = ServiceLocator.get(IWebSocketService)
            retry_count += 1
        
        # 检查服务是否可用
        if not self._websocket_service:
            self.logger.error("WebSocket 服务不可用，已尝试多次获取但失败")
            # 不要提前返回，继续初始化其他部分
        else:
            self.logger.info("成功获取WebSocket服务")
            # 设置评论服务
            if self._comment_service:
                self._websocket_service.set_comment_service(self._comment_service)
            
            # 注册事件监听器
            self._websocket_service.add_listener("message_received", self._on_message)
            self._websocket_service.add_listener("connection_status_changed", self._on_connection_status_changed)
        
        self.logger.info("WebSocket 控制器初始化完成")
    
    def start_server(self, port: int = 8765) -> bool:
        """
        启动 WebSocket 服务器
        
        @param port: 服务器端口
        @return: 是否成功启动
        """
        if not self._websocket_service:
            self.logger.error("WebSocket 服务不可用，无法启动服务器")
            self.error_occurred.emit("WebSocket 服务不可用")
            return False
        
        try:
            result = self._websocket_service.start_server(port)
            if result:
                self.logger.info(f"WebSocket 服务器已启动，端口: {port}")
            else:
                self.logger.error(f"WebSocket 服务器启动失败，端口: {port}")
                self.error_occurred.emit(f"WebSocket 服务器启动失败，端口: {port}")
            return result
        except Exception as e:
            error_msg = f"启动 WebSocket 服务器时发生错误: {str(e)}"
            self.logger.error(error_msg)
            self.error_occurred.emit(error_msg)
            return False
    
    def stop_server(self) -> bool:
        """
        停止 WebSocket 服务器
        
        @return: 是否成功停止
        """
        if not self._websocket_service:
            self.logger.error("WebSocket 服务不可用，无法停止服务器")
            self.error_occurred.emit("WebSocket 服务不可用")
            return False
        
        try:
            result = self._websocket_service.stop_server()
            if result:
                self.logger.info("WebSocket 服务器已停止")
            else:
                self.logger.error("WebSocket 服务器停止失败")
                self.error_occurred.emit("WebSocket 服务器停止失败")
            return result
        except Exception as e:
            error_msg = f"停止 WebSocket 服务器时发生错误: {str(e)}"
            self.logger.error(error_msg)
            self.error_occurred.emit(error_msg)
            return False
    
    def is_server_running(self) -> bool:
        """
        检查服务器是否运行中
        
        @return: 服务器是否运行
        """
        if not self._websocket_service:
            self.logger.warning("WebSocket 服务不可用，无法检查服务器状态")
            return False
        
        return self._websocket_service.is_server_running()
    
    def get_connection_status(self) -> str:
        """
        获取连接状态
        
        @return: 连接状态字符串
        """
        if not self._websocket_service:
            self.logger.warning("WebSocket 服务不可用，无法获取连接状态")
            return "未连接"
        
        return self._websocket_service.get_connection_status()
    
    def _on_message(self, message) -> None:
        """
        处理收到的消息
        
        @param message: 收到的消息，可能是Dict或Event对象
        """
        try:
            # 检查消息类型，如果是Event对象，则提取数据
            if hasattr(message, 'data') and hasattr(message, 'event_type'):
                # 这是一个Event对象
                data = message.data
            else:
                # 这是一个Dict对象
                data = message
            
            # 发送消息信号
            self.message_received.emit(data)
            
            # 记录消息
            self.logger.debug(f"处理消息: {json.dumps(data, ensure_ascii=False)[:100] if isinstance(data, dict) else str(data)[:100]}...")
        except Exception as e:
            self.logger.error(f"处理消息时发生错误: {str(e)}")
            import traceback
            self.logger.error(traceback.format_exc())
    
    def _on_connection_status_changed(self, event) -> None:
        """
        处理连接状态变化
        
        @param event: 状态变化事件
        """
        try:
            # 获取状态字符串
            status = event.data
            
            # 发送状态变化信号
            self.connection_status_changed.emit(status)
            
            # 记录状态变化
            self.logger.info(f"连接状态变化: {status}")
        except Exception as e:
            self.logger.error(f"处理连接状态变化时发生错误: {str(e)}")
    
    def shutdown(self) -> None:
        """
        关闭控制器
        """
        self.logger.info("WebSocket 控制器正在关闭...")
        
        # 停止服务器
        if self._websocket_service:
            try:
                # 移除事件监听器
                self._websocket_service.remove_listener("message_received", self._on_message)
                self._websocket_service.remove_listener("connection_status_changed", self._on_connection_status_changed)
                
                # 停止服务器
                self._websocket_service.stop_server()
            except Exception as e:
                self.logger.error(f"关闭 WebSocket 服务时发生错误: {str(e)}")
        
        self.logger.info("WebSocket 控制器已关闭") 